package shayu.search.thread;

import javassist.bytecode.analysis.Executor;

import java.util.concurrent.*;

public class Threadtest {
    public static void main(String[] args) {
        /**
         *  1. 继承Thread接口
         *  2. 实现Runnable接口
         *  3. 实现Callable接口+FutureTask(可以拿到返回结果，可以异常处理)
         *  4.线程池：给线程池直接提交任务
         *
         *  区别 1，2 不能得到返回值， 3可以得到返回值
         *  1，2，3 都不能对线程资源做控制
         *  4可以控制资源，性能稳定
         */

        /**
         *  七大参数
         *   corePoolSize[5] 核心线程数：一直存在，除非(allowCoreThreadTimeOut) 线程池创建好以后就准备执行
         *               5个 Thread thread =new Thread () thread.start();
         *   maximumPoolSize:[200]: 最大线程数量：控制资源
         *   keepAliveTime:存活时间，如果当前的线程数量大于core数量
         *              释放空闲的线程(maximumPoolSize-corePookSize)只要线程空闲大于指定的keepAliveTime
         *   unit：时间单位
         *   BlockingQueue(Runnable) workQueue:阻塞队列，如果任务有很多，就会将目前多的任务放在队列里面
         *                           只要有线程安全，就会去队列里面取出新的任务继续执行
         *   threadFactory:线程的创建工厂
         *   RejectedExecutionHandler handler：如果队列满了，按照我们指定的拒绝策略拒绝执行任务
         */

        /**
         *  工作顺序
         *      1. 线程池创建，准备好core数量的核心线程，准备接受任务
         *      1.1 core满了，就将在进来的任务放进阻塞队列，空闲的core就会自己去阻塞队列获取任务执行
         *      1.2 阻塞队列满了，就开始执行新线程执行，最大只能开到max指定的数量
         *      1.3 max满了就用RejectedExxceptionHandler拒绝任务
         *      1.4 max都执行完成，有很多空闲在指定时间keepAliveTime以后，释放max-core这些线程
         *
         *              new LinkedBlockingDequq<>（）默认是Integer的最大值，内存不够
         */

        new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());
        /**
         *      Executors.newCachedThreadPool() core是0，所有都可以回收
         *      Executors.newFixedThreadPool()  固定大小，core=max都不可回收
         *      Executors.newScheduledThreadPool() 定时任务的线程池
         *      Executors.newSingleThreadExecutor() 单线程的线程池，后台从队列里获取任务，挨个执行
         */

//        System.out.println("1");
//        CompletableFuture.runAsync(() -> {
//            System.out.println("当前线程");
//            int i = 10 / 2;
//            System.out.println("运行结果" + i);
//        }, executor);
//        System.out.println("main");

    }
}
